PART III c): German Credit Score Classification Model BIAS & FAIRNESS (Marital status as protected variable).
By: Krishna J¶
Importing necessary libraries ¶
In [1]:
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
#from sklearn.ensemble import RandomForestClassifier
#from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import MinMaxScaler, StandardScaler
from sklearn.base import TransformerMixin
from sklearn.pipeline import Pipeline, FeatureUnion
from typing import List, Union, Dict
# Warnings will be used to silence various model warnings for tidier output
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"
np.random.seed(0)
Importing source dataset ¶
In [2]:
German_df = pd.read_csv('C:/Users/krish/Downloads/German-reduced.csv')
print(German_df.shape)
print (German_df.columns)
In [3]:
German_df.head()
Out[3]:
In [4]:
#feature_list = ['Gender','Age','Marital_Status','NumMonths','Savings_<500','Savings_none','Dependents','Property_rent','Job_management/self-emp/officer/highly qualif emp','Debtors_guarantor','Purpose_CarNew', 'Purpose_furniture/equip','CreditHistory_none/paid','Purpose_CarUsed','CreditAmount','CreditStatus']
feature_list=['Gender','Age','Marital_Status','NumMonths','Savings_<500','Savings_none','Dependents','Property_rent',
'Job_management/self-emp/officer/highly qualif emp','Debtors_guarantor','Purpose_CarNew',
'Purpose_furniture/equip','CreditHistory_none/paid','Purpose_CarUsed','CreditAmount',
'Collateral_real estate','Debtors_none','Job_unemp/unskilled-non resident','Purpose_others',
'CreditHistory_other','PayBackPercent','Collateral_unknown/none','Purpose_education', 'CreditStatus']
In [5]:
X = German_df.iloc[:, :-1]
y = German_df['CreditStatus']
X.head()
y.head()
Out[5]:
Out[5]:
from imblearn.over_sampling import ADASYN from collections import Counter
ada = ADASYN(random_state=40) print('Original dataset shape {}'.format(Counter(y))) X_res, y_res = ada.fit_resample(X,y) print('Resampled dataset shape {}'.format(Counter(y_res)))
German_df=X = pd.DataFrame(np.column_stack((X_res, y_res)))
In [6]:
German_df.head()
Out[6]:
In [7]:
German_df.columns=feature_list
German_df.head()
Out[7]:
Metrics to calculate model fairness necessary libraries ¶
In [8]:
from aif360.datasets import GermanDataset
from aif360.metrics import BinaryLabelDatasetMetric
def fair_metrics(fname, dataset, pred, pred_is_dataset=False):
filename = fname
if pred_is_dataset:
dataset_pred = pred
else:
dataset_pred = dataset.copy()
dataset_pred.labels = pred
cols = ['Accuracy', 'F1', 'DI','SPD', 'EOD', 'AOD', 'ERD', 'CNT', 'TI']
obj_fairness = [[1,1,1,0,0,0,0,1,0]]
fair_metrics = pd.DataFrame(data=obj_fairness, index=['objective'], columns=cols)
for attr in dataset_pred.protected_attribute_names:
idx = dataset_pred.protected_attribute_names.index(attr)
privileged_groups = [{attr:dataset_pred.privileged_protected_attributes[idx][0]}]
unprivileged_groups = [{attr:dataset_pred.unprivileged_protected_attributes[idx][0]}]
classified_metric = ClassificationMetric(dataset,
dataset_pred,
unprivileged_groups=unprivileged_groups,
privileged_groups=privileged_groups)
metric_pred = BinaryLabelDatasetMetric(dataset_pred,
unprivileged_groups=unprivileged_groups,
privileged_groups=privileged_groups)
distortion_metric = SampleDistortionMetric(dataset,
dataset_pred,
unprivileged_groups=unprivileged_groups,
privileged_groups=privileged_groups)
acc = classified_metric.accuracy()
f1_sc = 2 * (classified_metric.precision() * classified_metric.recall()) / (classified_metric.precision() + classified_metric.recall())
mt = [acc, f1_sc,
classified_metric.disparate_impact(),
classified_metric.mean_difference(),
classified_metric.equal_opportunity_difference(),
classified_metric.average_odds_difference(),
classified_metric.error_rate_difference(),
metric_pred.consistency(),
classified_metric.theil_index()
]
w_row = []
print('Computing fairness of the model.')
for i in mt:
#print("%.8f"%i)
w_row.append("%.8f"%i)
with open(filename, 'a') as csvfile:
csvwriter = csv.writer(csvfile)
csvwriter.writerow(w_row)
row = pd.DataFrame([mt],
columns = cols,
index = [attr]
)
fair_metrics = fair_metrics.append(row)
fair_metrics = fair_metrics.replace([-np.inf, np.inf], 2)
return fair_metrics
def get_fair_metrics_and_plot(fname, data, model, plot=False, model_aif=False):
pred = model.predict(data).labels if model_aif else model.predict(data.features)
fair = fair_metrics(fname, data, pred)
if plot:
pass
return fair
def get_model_performance(X_test, y_true, y_pred, probs):
accuracy = accuracy_score(y_true, y_pred)
matrix = confusion_matrix(y_true, y_pred)
f1 = f1_score(y_true, y_pred)
return accuracy, matrix, f1
def plot_model_performance(model, X_test, y_true):
y_pred = model.predict(X_test)
probs = model.predict_proba(X_test)
accuracy, matrix, f1 = get_model_performance(X_test, y_true, y_pred, probs)
Local file to load metric values¶
In [9]:
filename= 'C:/Users/krish/Downloads/filename_mainpjt_results_apr_19_marital_status_na.csv'
Converting data to aif compatible format¶
Since we are dealing with binary label dataset we are using aif360 class BiaryLabelDataset here with target label as CreditStatus and protected attributes as age,gender,marital status. Refer part 11 for more details on protected attributes and privileged classes.
In [10]:
# Fairness metrics
from aif360.metrics import BinaryLabelDatasetMetric
from aif360.explainers import MetricTextExplainer
from aif360.metrics import ClassificationMetric
# Get DF into IBM format
from aif360 import datasets
#converting to aif dataset
aif_dataset = datasets.BinaryLabelDataset(favorable_label = 1, unfavorable_label = 0, df=German_df,
label_names=["CreditStatus"],
protected_attribute_names=["Marital_Status"],
privileged_protected_attributes = [1])
In [11]:
#dataset_orig = GermanDataset(protected_attribute_names=['sex'],
# privileged_classes=[[1]],
# features_to_keep=['age', 'sex', 'employment', 'housing', 'savings', 'credit_amount', 'month', 'purpose'],
# custom_preprocessing=custom_preprocessing)
Splitting data to train and test sets¶
In [12]:
#privileged_groups = [{'Age':1},{'Gender': 1},{'Marital_Status':1}]
#unprivileged_groups = [{'Age':0},{'Gender': 0},{'Marital_Status':0}]
In [13]:
privileged_groups = [{'Marital_Status': 1}]
unprivileged_groups = [{'Marital_Status': 0}]
In [14]:
data_orig_train, data_orig_test = aif_dataset.split([0.7], shuffle=True)
X_train = data_orig_train.features
y_train = data_orig_train.labels.ravel()
X_test = data_orig_test.features
y_test = data_orig_test.labels.ravel()
In [15]:
X_train.shape
X_test.shape
Out[15]:
Out[15]:
In [16]:
data_orig_test.labels[:10].ravel()
Out[16]:
In [17]:
data_orig_train.labels[:10].ravel()
Out[17]:
Building ML model ¶
Considering ensemble models for our study.
1. RANDOM FOREST CLASSIFIER MODEL¶
In [18]:
#Seting the Hyper Parameters
param_grid = {"max_depth": [3,5,7, 10,None],
"n_estimators":[3,5,10,25,50,150],
"max_features": [4,7,15,20]}
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
#Creating the classifier
rf_model = RandomForestClassifier(random_state=40)
grid_search = GridSearchCV(rf_model, param_grid=param_grid, cv=5, scoring='recall', verbose=0)
model_rf = grid_search
In [19]:
mdl_rf = model_rf.fit(data_orig_train.features, data_orig_train.labels.ravel())
In [20]:
from sklearn.metrics import confusion_matrix
conf_mat_rf = confusion_matrix(data_orig_test.labels.ravel(), model_rf.predict(data_orig_test.features))
conf_mat_rf
from sklearn.metrics import accuracy_score
print(accuracy_score(data_orig_test.labels.ravel(), model_rf.predict(data_orig_test.features)))
Out[20]:
In [21]:
unique, counts = np.unique(data_orig_test.labels.ravel(), return_counts=True)
dict(zip(unique, counts))
Out[21]:
1.a. Feature importance of model¶
In [22]:
importances = model_rf.best_estimator_.feature_importances_
indices = np.argsort(importances)
features = data_orig_train.feature_names
#https://stackoverflow.com/questions/48377296/get-feature-importance-from-gridsearchcv
In [23]:
importances
Out[23]:
In [24]:
importances[indices]
Out[24]:
In [25]:
features
Out[25]:
In [26]:
plt.figure(figsize=(20,30))
plt.title('Feature Importances')
plt.barh(range(len(indices)), importances[indices], color='b', align='center')
plt.yticks(range(len(indices)), [features[i] for i in indices])
plt.xlabel('Relative Importance')
plt.show()
Out[26]:
Out[26]:
Out[26]:
Out[26]:
Out[26]:
1.b. Model Explainability/interpretability¶
1.b.1 Using SHAP (SHapley Additive exPlanations)¶
In [27]:
import shap
Test data interpretation¶
In [28]:
rf_explainer = shap.KernelExplainer(model_rf.predict, data_orig_test.features)
rf_shap_values = rf_explainer.shap_values(data_orig_test.features,nsamples=50)
#https://towardsdatascience.com/explain-any-models-with-the-shap-values-use-the-kernelexplainer-79de9464897a
In [29]:
rf_shap_values
Out[29]:
In [30]:
rf_explainer.expected_value
Out[30]:
In [31]:
y_test_predict=model_rf.predict(data_orig_test.features)
y_test_predict[:12]
data_orig_test.labels[:12].ravel()
data_orig_test.features[:2,:]
Out[31]:
Out[31]:
Out[31]:
In [32]:
y_test_predict.mean()
Out[32]:
The explainer expected value is the average model predicted value on input data. Shapely helps to understand how individual features impact the output of each individual instance. The shapely values are model predicted values which may not coincide with actual y test values due to prediction error.
link=”logit” argument converts the logit values to probability
In [33]:
shap.initjs()
shap.force_plot(rf_explainer.expected_value,rf_shap_values[0],data_orig_test.features[0],data_orig_test.feature_names,link='logit')
#https://github.com/slundberg/shap
#https://github.com/slundberg/shap/issues/279
#https://github.com/slundberg/shap/issues/977
shap.initjs()
shap.force_plot(rf_explainer.expected_value,rf_shap_values[0],data_orig_test.features[0],data_orig_test.feature_names)
Out[33]:
Out[33]:
Features in blue pushes the base value towards lowest values and features in red moves base levels towards higher values.
Shapley values calculate the importance of a feature by comparing what a model predicts with and without the feature. However, since the order in which a model sees features can affect its predictions, this is done in every possible order, so that the features are fairly compared.
The SHAP plot shows features that contribute to pushing the output from the base value (average model output) to the actual predicted value.
In [34]:
shap.initjs()
shap.force_plot(rf_explainer.expected_value,rf_shap_values[1], data_orig_test.features[1],data_orig_test.feature_names,link='logit')
shap.initjs()
shap.force_plot(rf_explainer.expected_value,rf_shap_values[1], data_orig_test.features[1],data_orig_test.feature_names)
Out[34]:
Out[34]:
In [35]:
data_orig_test.feature_names
Out[35]:
In [36]:
shap.force_plot(rf_explainer.expected_value,
rf_shap_values, data_orig_test.features[:,:],feature_names = data_orig_test.feature_names)
Out[36]:
In [37]:
p = shap.summary_plot(rf_shap_values, data_orig_test.features, feature_names=data_orig_test.feature_names,plot_type="bar")
display(p)
Variables with higher impact are displayed at the credit history, credit amount,num of months.
In [38]:
shap.decision_plot(rf_explainer.expected_value, rf_shap_values,feature_names=data_orig_test.feature_names)
- The x-axis represents the model's output. In this case, the units are log odds.
- The plot is centered on the x-axis at explainer.expected_value.
- All SHAP values are relative to the model's expected value like a linear model's effects are relative to the intercept.
- The y-axis lists the model's features.
- By default, the features are ordered by descending importance. The importance is calculated over the observations plotted. This is usually different than the importance ordering for the entire dataset.
- In addition to feature importance ordering, the decision plot also supports hierarchical cluster feature ordering and user-defined feature ordering.
- Each observation's prediction is represented by a colored line. At the top of the plot, each line strikes the x-axis at its corresponding observation's predicted value. This value determines the color of the line on a spectrum.
- Moving from the bottom of the plot to the top, SHAP values for each feature are added to the model's base value. This shows how each feature contributes to the overall prediction.
- At the bottom of the plot, the observations converge at explainer.expected_value https://slundberg.github.io/shap/notebooks/plots/decision_plot.html
Like the force plot, the decision plot supports link='logit' to transform log odds to probabilities.
In [39]:
shap.decision_plot(rf_explainer.expected_value, rf_shap_values,feature_names=data_orig_test.feature_names,link='logit')
In [40]:
shap.plots._waterfall.waterfall_legacy(rf_explainer.expected_value, rf_shap_values[0],feature_names=data_orig_test.feature_names)
For first instace of input,out of all the displayed variables, CreditHistory with value other is playing major role is pushing the target variable outcome towards predicting 1.
Interpretation of graph: https://shap.readthedocs.io/en/latest/example_notebooks/overviews/An%20introduction%20to%20explainable%20AI%20with%20Shapley%20values.html
f(x)- model output impacted by features; E(f(x))- expected output.
One the fundemental properties of Shapley values is that they always sum up to the difference between the game outcome when all players are present and the game outcome when no players are present. For machine learning models this means that SHAP values of all the input features will always sum up to the difference between baseline (expected) model output and the current model output for the prediction being explained.
Shapley values calculate the importance of a feature by comparing what a model predicts with and without the feature. However, since the order in which a model sees features can affect its predictions, this is done in every possible order, so that the features are fairly compared. https://medium.com/@gabrieltseng/interpreting-complex-models-with-shap-values-1c187db6ec83
In [41]:
shap.plots._waterfall.waterfall_legacy(rf_explainer.expected_value, rf_shap_values[1],feature_names=data_orig_test.feature_names)
For second instace of input,out of all the displayed variables, credit amount is playing major role is pushing the target variable outcome towards predicting 0.
1.b.2 Using ELI5¶
In [42]:
#!pip install eli5
import eli5
from eli5.sklearn import PermutationImportance
In [43]:
perm_rf = PermutationImportance(mdl_rf).fit(data_orig_test.features, data_orig_test.labels.ravel())
Feature Importance¶
In [44]:
perm_imp_1=eli5.show_weights(perm_rf,feature_names = data_orig_test.feature_names)
perm_imp_1
plt.show()
Out[44]:
- eli5 provides a way to compute feature importances for any black-box estimator by measuring how score decreases when a feature is not available; the method is also known as “permutation importance” or “Mean Decrease Accuracy (MDA)”.
The first number in each row shows how much model performance decreased with a random shuffling (in this case, using "accuracy" as the performance metric).
Like most things in data science, there is some randomness to the exact performance change from a shuffling a column. We measure the amount of randomness in our permutation importance calculation by repeating the process with multiple shuffles. The number after the ± measures how performance varied from one-reshuffling to the next.
You'll occasionally see negative values for permutation importances. In those cases, the predictions on the shuffled (or noisy) data happened to be more accurate than the real data. This happens when the feature didn't matter (should have had an importance close to 0), but random chance caused the predictions on shuffled data to be more accurate. This is more common with small datasets, like the one in this example, because there is more room for luck/chance.
1.c. Measuring fairness ¶
Of Baseline model ¶
In [45]:
import pandas as pd
import csv
import os
import numpy as np
import sys
from aif360.metrics import *
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, roc_curve, auc
plot_model_performance(mdl_rf, X_test, y_test)
In [46]:
fair_rf = get_fair_metrics_and_plot(filename, data_orig_test, mdl_rf)
fair_rf
Out[46]:
In [47]:
type(data_orig_train)
Out[47]:
PRE PROCESSING¶
In [48]:
### Reweighing
from aif360.algorithms.preprocessing import Reweighing
RW_rf = Reweighing(unprivileged_groups=unprivileged_groups, privileged_groups=privileged_groups)
data_transf_train_rf_rw = RW_rf.fit_transform(data_orig_train)
#train and save model
rf_transf_rw = model_rf.fit(data_transf_train_rf_rw.features,
data_transf_train_rf_rw.labels.ravel())
data_transf_test_rf_rw = RW_rf.transform(data_orig_test)
fair_rf_rw = get_fair_metrics_and_plot(filename, data_transf_test_rf_rw, rf_transf_rw, plot=False)
In [49]:
fair_rf_rw
Out[49]:
In [50]:
from aif360.algorithms.preprocessing import DisparateImpactRemover
DIR_rf = DisparateImpactRemover()
data_transf_train_rf_dir = DIR_rf.fit_transform(data_orig_train)
# Train and save the model
rf_transf_dir = model_rf.fit(data_transf_train_rf_dir.features,data_transf_train_rf_dir.labels.ravel())
In [51]:
fair_dir_rf_dir = get_fair_metrics_and_plot(filename,data_orig_test, rf_transf_dir, plot=False)
fair_dir_rf_dir
Out[51]:
INPROCESSING¶
In [52]:
#!pip install --user --upgrade tensorflow==1.15.0
#2.2.0
#!pip uninstall tensorflow
In [53]:
#!pip install "tensorflow==1.15"
#!pip install --upgrade tensorflow-hub
In [54]:
#%tensorflow_version 1.15
import tensorflow as tf
#from tensorflow.compat.v1 import variable_scope
print('Using TensorFlow version', tf.__version__)
In [55]:
#sess = tf.compat.v1.Session()
#import tensorflow as tf
sess = tf.compat.v1.Session()
In [56]:
#import tensorflow as tf
#sess = tf.Session()
tf.compat.v1.reset_default_graph()
In [57]:
from aif360.algorithms.inprocessing.adversarial_debiasing import AdversarialDebiasing
#with tf.variable_scope('debiased_classifier',reuse=tf.AUTO_REUSE):
with tf.compat.v1.Session() as sess:
with tf.variable_scope('scope1',reuse=tf.AUTO_REUSE) as scope:
debiased_model_rf_ad = AdversarialDebiasing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
scope_name=scope,
num_epochs=10,
debias=True,
sess=sess)
#train and save the model
debiased_model_rf_ad.fit(data_orig_train)
fair_rf_ad = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_rf_ad, plot=False, model_aif=True)
Out[57]:
In [58]:
fair_rf_ad
Out[58]:
In [59]:
from aif360.algorithms.inprocessing import PrejudiceRemover
debiased_model_pr_rf = PrejudiceRemover()
# Train and save the model
debiased_model_pr_rf.fit(data_orig_train)
fair_rf_pr = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_pr_rf, plot=False, model_aif=True)
fair_rf_pr
Out[59]:
Out[59]:
#¶
In [60]:
y_pred = debiased_model_pr_rf.predict(data_orig_test)
data_orig_test_pred = data_orig_test.copy(deepcopy=True)
In [61]:
# Prediction with the original RandomForest model
scores = np.zeros_like(data_orig_test.labels)
scores = mdl_rf.predict_proba(data_orig_test.features)[:,1].reshape(-1,1)
data_orig_test_pred.scores = scores
preds = np.zeros_like(data_orig_test.labels)
preds = mdl_rf.predict(data_orig_test.features).reshape(-1,1)
data_orig_test_pred.labels = preds
def format_probs(probs1):
probs1 = np.array(probs1)
probs0 = np.array(1-probs1)
return np.concatenate((probs0, probs1), axis=1)
POST PROCESSING¶
In [62]:
from aif360.algorithms.postprocessing import EqOddsPostprocessing
EOPP_rf = EqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
seed=40)
EOPP_rf = EOPP_rf.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_rf_eopp = EOPP_rf.predict(data_orig_test_pred)
fair_rf_eo = fair_metrics(filename, data_orig_test, data_transf_test_pred_rf_eopp, pred_is_dataset=True)
In [63]:
fair_rf_eo
Out[63]:
In [64]:
from aif360.algorithms.postprocessing import CalibratedEqOddsPostprocessing
cost_constraint = "fnr"
CPP_rf = CalibratedEqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
cost_constraint=cost_constraint,
seed=42)
CPP_rf = CPP_rf.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_rf_cpp = CPP_rf.predict(data_orig_test_pred)
fair_rf_ceo = fair_metrics(filename, data_orig_test, data_transf_test_pred_rf_cpp, pred_is_dataset=True)
In [65]:
fair_rf_ceo
Out[65]:
In [66]:
from aif360.algorithms.postprocessing import RejectOptionClassification
ROC_rf = RejectOptionClassification(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups)
ROC_rf = ROC_rf.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_rf_roc = ROC_rf.predict(data_orig_test_pred)
fair_rf_roc = fair_metrics(filename, data_orig_test, data_transf_test_pred_rf_roc, pred_is_dataset=True)
print('SUCCESS: completed 1 model.')
In [67]:
fair_rf_roc
Out[67]:
2. XGBoost Classifier¶
In [68]:
from xgboost import XGBClassifier
estimator = XGBClassifier(seed=40)
parameters = {
'max_depth': range (2, 10, 2),
'n_estimators': range(60, 240, 40),
'learning_rate': [0.1, 0.01, 0.05]
}
grid_search = GridSearchCV(
estimator=estimator,
param_grid=parameters,
scoring = 'recall',
cv = 5,
verbose=0
)
model_xg=grid_search
In [69]:
mdl_xgb = model_xg.fit(data_orig_train.features, data_orig_train.labels.ravel())
In [70]:
conf_mat_xg = confusion_matrix(data_orig_test.labels.ravel(), model_xg.predict(data_orig_test.features))
conf_mat_xg
from sklearn.metrics import accuracy_score
print(accuracy_score(data_orig_test.labels.ravel(), model_xg.predict(data_orig_test.features)))
Out[70]:
2.a. Feature importance of model¶
In [71]:
importances_xg = model_xg.best_estimator_.feature_importances_
indices_xg = np.argsort(importances_xg)
features = data_orig_train.feature_names
#https://stackoverflow.com/questions/48377296/get-feature-importance-from-gridsearchcv
In [72]:
importances_xg
Out[72]:
In [73]:
importances_xg[indices_xg]
Out[73]:
In [74]:
features
Out[74]:
In [75]:
plt.figure(figsize=(20,30))
plt.title('Feature Importances')
plt.barh(range(len(indices_xg)), importances_xg[indices_xg], color='b', align='center')
plt.yticks(range(len(indices_xg)), [features[i] for i in indices_xg])
plt.xlabel('Relative Importance')
plt.show()
Out[75]:
Out[75]:
Out[75]:
Out[75]:
Out[75]:
2.b. Model Explainability/interpretability¶
2.b.1 Using SHAP (SHapley Additive exPlanations)¶
In [76]:
import shap
xg_shap_values_t1 = shap.KernelExplainer(mdl_xgb.predict,data_orig_train.features)
Test data interpretation¶
In [78]:
xgb_explainer = shap.KernelExplainer(mdl_xgb.predict, data_orig_test.features)
xgb_shap_values = xgb_explainer.shap_values(data_orig_test.features,nsamples=10)
#https://towardsdatascience.com/explain-any-models-with-the-shap-values-use-the-kernelexplainer-79de9464897a
In [79]:
xgb_shap_values
Out[79]:
In [80]:
shap.initjs()
shap.force_plot(xgb_explainer.expected_value,xgb_shap_values[0,:], data_orig_test.features[0],data_orig_test.feature_names,link='logit')
#https://github.com/slundberg/shap
#https://github.com/slundberg/shap/issues/279
Out[80]:
In [81]:
shap.initjs()
shap.force_plot(xgb_explainer.expected_value,xgb_shap_values[1,:], data_orig_test.features[1],data_orig_test.feature_names,link='logit')
Out[81]:
In [82]:
shap.force_plot(xgb_explainer.expected_value,
xgb_shap_values, data_orig_test.features[:,:],feature_names = data_orig_test.feature_names)
Out[82]:
In [83]:
p = shap.summary_plot(xgb_shap_values, data_orig_test.features, feature_names=data_orig_test.feature_names,plot_type="bar")
display(p)
The variables with higher impact are the ones in the top age,gender,marital status.
In [84]:
shap.plots._waterfall.waterfall_legacy(xgb_explainer.expected_value, xgb_shap_values[0,:],feature_names=data_orig_test.feature_names)
Here credit history other and age are moving target outcome towards right i.e., 1.
Interpretation of graph: https://shap.readthedocs.io/en/latest/example_notebooks/overviews/An%20introduction%20to%20explainable%20AI%20with%20Shapley%20values.html
f(x)- model output impacted by features; E(f(x))- expected output.
One the fundemental properties of Shapley values is that they always sum up to the difference between the game outcome when all players are present and the game outcome when no players are present. For machine learning models this means that SHAP values of all the input features will always sum up to the difference between baseline (expected) model output and the current model output for the prediction being explained.
In [85]:
shap.plots._waterfall.waterfall_legacy(xgb_explainer.expected_value, xgb_shap_values[1],feature_names=data_orig_test.feature_names)
Here Credit Amount is moving the target result towards zero.
2.b.2 Using ELI5¶
In [86]:
#!pip install eli5
import eli5
from eli5.sklearn import PermutationImportance
In [87]:
perm_xgb = PermutationImportance(mdl_xgb).fit(data_orig_test.features, data_orig_test.labels.ravel())
Feature Importance¶
In [88]:
perm_imp_2=eli5.show_weights(perm_xgb,feature_names = data_orig_test.feature_names)
perm_imp_2
plt.show()
Out[88]:
2.c. Measuring fairness ¶
Of Baseline model ¶
In [89]:
import pandas as pd
import csv
import os
import numpy as np
import sys
from aif360.metrics import *
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, roc_curve, auc
plot_model_performance(mdl_xgb, X_test, y_test)
In [90]:
fair_xg = get_fair_metrics_and_plot(filename, data_orig_test, model_xg)
fair_xg
Out[90]:
PRE PROCESSING¶
In [91]:
### Reweighing
from aif360.algorithms.preprocessing import Reweighing
RW_xg = Reweighing(unprivileged_groups=unprivileged_groups, privileged_groups=privileged_groups)
data_transf_train_xg_rw = RW_xg.fit_transform(data_orig_train)
#train and save model
xg_transf_rw = model_xg.fit(data_transf_train_xg_rw.features,
data_transf_train_xg_rw.labels.ravel())
data_transf_test_xg_rw = RW_xg.transform(data_orig_test)
fair_xg_rw = get_fair_metrics_and_plot(filename, data_transf_test_xg_rw, xg_transf_rw, plot=False)
In [92]:
fair_xg_rw
Out[92]:
In [93]:
from aif360.algorithms.preprocessing import DisparateImpactRemover
DIR_xg = DisparateImpactRemover()
data_transf_train_xg_dir = DIR_xg.fit_transform(data_orig_train)
# Train and save the model
xg_transf_dir = model_xg.fit(data_transf_train_xg_dir.features,data_transf_train_xg_dir.labels.ravel())
In [94]:
fair_dir_xg_dir = get_fair_metrics_and_plot(filename,data_orig_test, xg_transf_dir, plot=False)
fair_dir_xg_dir
Out[94]:
INPROCESSING¶
In [95]:
#!pip install --user --upgrade tensorflow==1.15.0
#2.2.0
#!pip uninstall tensorflow
In [96]:
#!pip install "tensorflow==1.15"
#!pip install --upgrade tensorflow-hub
In [97]:
#%tensorflow_version 1.15
import tensorflow as tf
#from tensorflow.compat.v1 import variable_scope
print('Using TensorFlow version', tf.__version__)
In [98]:
#sess = tf.compat.v1.Session()
#import tensorflow as tf
sess = tf.compat.v1.Session()
In [99]:
#import tensorflow as tf
#sess = tf.Session()
tf.compat.v1.reset_default_graph()
In [100]:
from aif360.algorithms.inprocessing.adversarial_debiasing import AdversarialDebiasing
#with tf.variable_scope('debiased_classifier',reuse=tf.AUTO_REUSE):
with tf.compat.v1.Session() as sess:
with tf.variable_scope('scope1',reuse=tf.AUTO_REUSE) as scope:
debiased_model_xg_ad = AdversarialDebiasing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
scope_name=scope,
num_epochs=10,
debias=True,
sess=sess)
#train and save the model
debiased_model_xg_ad.fit(data_orig_train)
fair_xg_ad = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_xg_ad, plot=False, model_aif=True)
Out[100]:
In [101]:
fair_xg_ad
Out[101]:
In [102]:
from aif360.algorithms.inprocessing import PrejudiceRemover
debiased_model_pr_xg = PrejudiceRemover()
# Train and save the model
debiased_model_pr_xg.fit(data_orig_train)
fair_xg_pr = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_pr_xg, plot=False, model_aif=True)
fair_xg_pr
Out[102]:
Out[102]:
#¶
In [103]:
y_pred = debiased_model_pr_xg.predict(data_orig_test)
data_orig_test_pred = data_orig_test.copy(deepcopy=True)
In [104]:
# Prediction with the original RandomForest model
scores = np.zeros_like(data_orig_test.labels)
scores = mdl_xgb.predict_proba(data_orig_test.features)[:,1].reshape(-1,1)
data_orig_test_pred.scores = scores
preds = np.zeros_like(data_orig_test.labels)
preds = mdl_xgb.predict(data_orig_test.features).reshape(-1,1)
data_orig_test_pred.labels = preds
def format_probs(probs1):
probs1 = np.array(probs1)
probs0 = np.array(1-probs1)
return np.concatenate((probs0, probs1), axis=1)
POST PROCESSING¶
In [105]:
from aif360.algorithms.postprocessing import EqOddsPostprocessing
EOPP_xg = EqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
seed=40)
EOPP_xg = EOPP_xg.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_xg_eopp = EOPP_xg.predict(data_orig_test_pred)
fair_xg_eo = fair_metrics(filename, data_orig_test, data_transf_test_pred_xg_eopp, pred_is_dataset=True)
In [106]:
fair_xg_eo
Out[106]:
In [107]:
from aif360.algorithms.postprocessing import CalibratedEqOddsPostprocessing
cost_constraint = "fnr"
CPP_xg = CalibratedEqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
cost_constraint=cost_constraint,
seed=42)
CPP_xg = CPP_xg.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_xg_cpp = CPP_xg.predict(data_orig_test_pred)
fair_xg_ceo = fair_metrics(filename, data_orig_test, data_transf_test_pred_xg_cpp, pred_is_dataset=True)
In [108]:
fair_xg_ceo
Out[108]:
In [109]:
from aif360.algorithms.postprocessing import RejectOptionClassification
ROC_xg = RejectOptionClassification(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups)
ROC_xg = ROC_xg.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_xg_roc = ROC_xg.predict(data_orig_test_pred)
fair_xg_roc = fair_metrics(filename, data_orig_test, data_transf_test_pred_xg_roc, pred_is_dataset=True)
print('SUCCESS: completed 1 model.')
In [110]:
fair_xg_roc
Out[110]:
In [ ]:
In [ ]:
3. XGBOOST with out hyper-parameter tuning¶
In [111]:
from xgboost import XGBClassifier
model_xgb2 = XGBClassifier(seed=40)
In [112]:
mdl_xgb2 = model_xgb2.fit(data_orig_train.features, data_orig_train.labels.ravel())
In [113]:
conf_mat_xg2 = confusion_matrix(data_orig_test.labels.ravel(), model_xgb2.predict(data_orig_test.features))
conf_mat_xg2
from sklearn.metrics import accuracy_score
print(accuracy_score(data_orig_test.labels.ravel(), model_xgb2.predict(data_orig_test.features)))
Out[113]:
3.a. Feature importance of model¶
In [114]:
importances_xg2 = model_xgb2.feature_importances_
indices_xg2 = np.argsort(importances_xg2)
features2 = data_orig_train.feature_names
#https://stackoverflow.com/questions/48377296/get-feature-importance-from-gridsearchcv
In [115]:
importances_xg2
Out[115]:
In [116]:
importances_xg2[indices_xg2]
Out[116]:
In [117]:
features2
Out[117]:
In [118]:
plt.figure(figsize=(20,30))
plt.title('Feature Importances')
plt.barh(range(len(indices_xg2)), importances_xg2[indices_xg2], color='b', align='center')
plt.yticks(range(len(indices_xg2)), [features2[i] for i in indices_xg2])
plt.xlabel('Relative Importance')
plt.show()
Out[118]:
Out[118]:
Out[118]:
Out[118]:
Out[118]:
3.b. Model Explainability/interpretability¶
3.b.1 Using SHAP (SHapley Additive exPlanations)¶
In [119]:
import shap
xg_shap_values_t = shap.KernelExplainer(mdl_xgb2.predict,data_orig_train.features)
Test data interpretation¶
In [120]:
xgb_explainer2 = shap.KernelExplainer(mdl_xgb2.predict, data_orig_test.features)
xgb_shap_values2 = xgb_explainer2.shap_values(data_orig_test.features,nsamples=10)
#https://towardsdatascience.com/explain-any-models-with-the-shap-values-use-the-kernelexplainer-79de9464897a
In [121]:
xgb_shap_values2
Out[121]:
In [122]:
shap.initjs()
shap.force_plot(xgb_explainer2.expected_value,xgb_shap_values2[0,:], data_orig_test.features[0],data_orig_test.feature_names,link='logit')
#https://github.com/slundberg/shap
#https://github.com/slundberg/shap/issues/279
Out[122]:
The field age is pushing target outcome towards lower value and collateral unknown/none, purpose others are pushing the target towards higher value which resulted in the final probability of occurrance as .73
In [123]:
shap.initjs()
shap.force_plot(xgb_explainer2.expected_value,xgb_shap_values2[1,:], data_orig_test.features[1],data_orig_test.feature_names,link='logit')
Out[123]:
Here only credit amount has impact in moving target outcome towards lower value than the base value which is the mean value to target outcome
In [124]:
data_orig_test.feature_names
Out[124]:
In [125]:
shap.force_plot(xgb_explainer2.expected_value,
xgb_shap_values2, data_orig_test.features[:,:],feature_names = data_orig_test.feature_names)
Out[125]:
In [126]:
p = shap.summary_plot(xgb_shap_values2, data_orig_test.features, feature_names=data_orig_test.feature_names,plot_type="bar")
display(p)
variables with higher impact are CreditAmount,NumMonths,Savings.
In [127]:
shap.plots._waterfall.waterfall_legacy(xgb_explainer2.expected_value, xgb_shap_values2[0,:],feature_names=data_orig_test.feature_names)
Here purpose other and collateral unknown/none are pushing target to higher value and age is pushing it towards lower value.
Interpretation of graph: https://shap.readthedocs.io/en/latest/example_notebooks/overviews/An%20introduction%20to%20explainable%20AI%20with%20Shapley%20values.html
f(x)- model output impacted by features; E(f(x))- expected output.
One the fundemental properties of Shapley values is that they always sum up to the difference between the game outcome when all players are present and the game outcome when no players are present. For machine learning models this means that SHAP values of all the input features will always sum up to the difference between baseline (expected) model output and the current model output for the prediction being explained.
In [128]:
shap.plots._waterfall.waterfall_legacy(xgb_explainer2.expected_value, xgb_shap_values2[1],feature_names=data_orig_test.feature_names)
3.b.2 Using ELI5¶
In [129]:
#!pip install eli5
import eli5
from eli5.sklearn import PermutationImportance
In [130]:
perm_xgb2 = PermutationImportance(mdl_xgb2).fit(data_orig_test.features, data_orig_test.labels.ravel())
Feature Importance¶
In [131]:
perm_imp_3=eli5.show_weights(perm_xgb2,feature_names = data_orig_test.feature_names)
perm_imp_3
plt.show()
Out[131]:
Explaining individual predictions¶
In [132]:
from eli5 import show_prediction
show_prediction(mdl_xgb2, data_orig_test.features[1], show_feature_values=True,feature_names = data_orig_test.feature_names)
Out[132]:
In [ ]:
3.c. Measuring fairness ¶
Of Baseline model ¶
In [133]:
import pandas as pd
import csv
import os
import numpy as np
import sys
from aif360.metrics import *
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, roc_curve, auc
plot_model_performance(mdl_xgb2, X_test, y_test)
In [134]:
fair_xg2 = get_fair_metrics_and_plot(filename, data_orig_test, mdl_xgb2)
fair_xg2
Out[134]:
PRE PROCESSING¶
In [135]:
### Reweighing
from aif360.algorithms.preprocessing import Reweighing
RW_xg2 = Reweighing(unprivileged_groups=unprivileged_groups, privileged_groups=privileged_groups)
data_transf_train_xg2_rw = RW_xg2.fit_transform(data_orig_train)
#train and save model
xg2_transf_rw = model_xgb2.fit(data_transf_train_xg2_rw.features,
data_transf_train_xg2_rw.labels.ravel())
data_transf_test_xg2_rw = RW_xg2.transform(data_orig_test)
fair_xg2_rw = get_fair_metrics_and_plot(filename, data_transf_test_xg2_rw, xg2_transf_rw, plot=False)
In [136]:
fair_xg2_rw
Out[136]:
In [137]:
from aif360.algorithms.preprocessing import DisparateImpactRemover
DIR_xg2 = DisparateImpactRemover()
data_transf_train_xg2_dir = DIR_xg2.fit_transform(data_orig_train)
# Train and save the model
xg2_transf_dir = model_xgb2.fit(data_transf_train_xg2_dir.features,data_transf_train_xg2_dir.labels.ravel())
In [138]:
fair_dir_xg2_dir = get_fair_metrics_and_plot(filename,data_orig_test, xg2_transf_dir, plot=False)
fair_dir_xg2_dir
Out[138]:
INPROCESSING¶
In [139]:
#!pip install --user --upgrade tensorflow==1.15.0
#2.2.0
#!pip uninstall tensorflow
In [140]:
#!pip install "tensorflow==1.15"
#!pip install --upgrade tensorflow-hub
In [141]:
#%tensorflow_version 1.15
import tensorflow as tf
#from tensorflow.compat.v1 import variable_scope
print('Using TensorFlow version', tf.__version__)
In [142]:
#sess = tf.compat.v1.Session()
#import tensorflow as tf
sess = tf.compat.v1.Session()
In [143]:
#import tensorflow as tf
#sess = tf.Session()
tf.compat.v1.reset_default_graph()
In [144]:
from aif360.algorithms.inprocessing.adversarial_debiasing import AdversarialDebiasing
#with tf.variable_scope('debiased_classifier',reuse=tf.AUTO_REUSE):
with tf.compat.v1.Session() as sess:
with tf.variable_scope('scope1',reuse=tf.AUTO_REUSE) as scope:
debiased_model_xg2_ad = AdversarialDebiasing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
scope_name=scope,
num_epochs=10,
debias=True,
sess=sess)
#train and save the model
debiased_model_xg2_ad.fit(data_orig_train)
fair_xg2_ad = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_xg2_ad, plot=False, model_aif=True)
Out[144]:
In [145]:
fair_xg2_ad
Out[145]:
In [146]:
from aif360.algorithms.inprocessing import PrejudiceRemover
debiased_model_pr_xg2 = PrejudiceRemover()
# Train and save the model
debiased_model_pr_xg2.fit(data_orig_train)
fair_xg2_pr = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_pr_xg2, plot=False, model_aif=True)
fair_xg2_pr
Out[146]:
Out[146]:
#¶
In [147]:
y_pred = debiased_model_pr_xg2.predict(data_orig_test)
data_orig_test_pred = data_orig_test.copy(deepcopy=True)
In [148]:
# Prediction with the original RandomForest model
scores = np.zeros_like(data_orig_test.labels)
scores = mdl_xgb2.predict_proba(data_orig_test.features)[:,1].reshape(-1,1)
data_orig_test_pred.scores = scores
preds = np.zeros_like(data_orig_test.labels)
preds = mdl_xgb2.predict(data_orig_test.features).reshape(-1,1)
data_orig_test_pred.labels = preds
def format_probs(probs1):
probs1 = np.array(probs1)
probs0 = np.array(1-probs1)
return np.concatenate((probs0, probs1), axis=1)
POST PROCESSING¶
In [149]:
from aif360.algorithms.postprocessing import EqOddsPostprocessing
EOPP_xg2 = EqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
seed=40)
EOPP_xg2 = EOPP_xg2.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_xg2_eopp = EOPP_xg2.predict(data_orig_test_pred)
fair_xg2_eo = fair_metrics(filename, data_orig_test, data_transf_test_pred_xg2_eopp, pred_is_dataset=True)
In [150]:
fair_xg2_eo
Out[150]:
In [151]:
from aif360.algorithms.postprocessing import CalibratedEqOddsPostprocessing
cost_constraint = "fnr"
CPP_xg2 = CalibratedEqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
cost_constraint=cost_constraint,
seed=42)
CPP_xg2 = CPP_xg2.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_xg2_cpp = CPP_xg2.predict(data_orig_test_pred)
fair_xg2_ceo = fair_metrics(filename, data_orig_test, data_transf_test_pred_xg2_cpp, pred_is_dataset=True)
In [152]:
fair_xg2_ceo
Out[152]:
In [153]:
from aif360.algorithms.postprocessing import RejectOptionClassification
ROC_xg2 = RejectOptionClassification(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups)
ROC_xg2 = ROC_xg2.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_xg2_roc = ROC_xg2.predict(data_orig_test_pred)
fair_xg2_roc = fair_metrics(filename, data_orig_test, data_transf_test_pred_xg2_roc, pred_is_dataset=True)
print('SUCCESS: completed 1 model.')
In [154]:
fair_xg2_roc
Out[154]:
In [ ]:
4. RANDOM FOREST CLASSIFIER MODEL WITH OUT HYPER-PARAMETER TUNING¶
In [155]:
#Creating the classifier
rf_model2 = RandomForestClassifier(random_state=40)
model_rf2=rf_model2
In [156]:
mdl_rf2 = model_rf2.fit(data_orig_train.features, data_orig_train.labels.ravel())
In [157]:
from sklearn.metrics import confusion_matrix
conf_mat_rf2 = confusion_matrix(data_orig_test.labels.ravel(), model_rf2.predict(data_orig_test.features))
conf_mat_rf2
from sklearn.metrics import accuracy_score
print(accuracy_score(data_orig_test.labels.ravel(), model_rf2.predict(data_orig_test.features)))
Out[157]:
In [158]:
unique, counts = np.unique(data_orig_test.labels.ravel(), return_counts=True)
dict(zip(unique, counts))
Out[158]:
4.a. Model Explainability/interpretability¶
4.a.1 Using SHAP (SHapley Additive exPlanations)¶
In [159]:
import shap
rf_shap_values_t2 = shap.KernelExplainer(mdl_rf2.predict,data_orig_train.features)
Test data interpretation¶
In [160]:
rf_explainer2 = shap.KernelExplainer(mdl_rf2.predict, data_orig_test.features)
rf_shap_values2 = rf_explainer2.shap_values(data_orig_test.features,nsamples=10)
#https://towardsdatascience.com/explain-any-models-with-the-shap-values-use-the-kernelexplainer-79de9464897a
In [161]:
rf_shap_values2
Out[161]:
In [162]:
rf_explainer2.expected_value
rf_shap_values2
Out[162]:
Out[162]:
In [163]:
shap.initjs()
shap.force_plot(rf_explainer2.expected_value,rf_shap_values2[0,:], data_orig_test.features[0],data_orig_test.feature_names,link='logit')
#https://github.com/slundberg/shap
#https://github.com/slundberg/shap/issues/279
Out[163]:
In [164]:
shap.initjs()
shap.force_plot(rf_explainer2.expected_value,rf_shap_values2[1,:], data_orig_test.features[1],data_orig_test.feature_names,link='logit')
Out[164]:
In [165]:
shap.initjs()
shap.force_plot(rf_explainer2.expected_value,rf_shap_values2[2,:], data_orig_test.features[2],data_orig_test.feature_names,link='logit')
Out[165]:
In [166]:
data_orig_test.feature_names
Out[166]:
In [167]:
shap.force_plot(rf_explainer2.expected_value,
rf_shap_values2, data_orig_test.features[:,:],feature_names = data_orig_test.feature_names)
Out[167]:
In [168]:
p = shap.summary_plot(rf_shap_values2, data_orig_test.features, feature_names=data_orig_test.feature_names,plot_type="bar")
display(p)
Variables with higher impact are displayed at the top such as gender,age,nummonths etc
In [169]:
shap.plots._waterfall.waterfall_legacy(rf_explainer2.expected_value, rf_shap_values2[0,:],feature_names=data_orig_test.feature_names)
Interpretation of graph: https://shap.readthedocs.io/en/latest/example_notebooks/overviews/An%20introduction%20to%20explainable%20AI%20with%20Shapley%20values.html
f(x)- model output impacted by features; E(f(x))- expected output.
One the fundemental properties of Shapley values is that they always sum up to the difference between the game outcome when all players are present and the game outcome when no players are present. For machine learning models this means that SHAP values of all the input features will always sum up to the difference between baseline (expected) model output and the current model output for the prediction being explained.
In [170]:
shap.plots._waterfall.waterfall_legacy(rf_explainer2.expected_value, rf_shap_values2[1],feature_names=data_orig_test.feature_names)
4.a.2 Using ELI5¶
In [171]:
#!pip install eli5
import eli5
from eli5.sklearn import PermutationImportance
In [172]:
perm_rf2 = PermutationImportance(mdl_rf2).fit(data_orig_test.features, data_orig_test.labels.ravel())
In [173]:
data_orig_test.labels[:10,:].ravel()
Out[173]:
Feature Importance¶
In [174]:
perm_imp_11=eli5.show_weights(perm_rf2,feature_names = data_orig_test.feature_names)
perm_imp_11
plt.show()
Out[174]:
Explaining individual predictions¶
In [175]:
show_prediction(mdl_rf2, data_orig_test.features[0], show_feature_values=True,feature_names = data_orig_test.feature_names)
Out[175]:
In [176]:
from eli5 import show_prediction
show_prediction(mdl_rf2, data_orig_test.features[1], show_feature_values=True,feature_names = data_orig_test.feature_names)
Out[176]:
4.b. Measuring fairness ¶
Of Baseline model ¶
In [177]:
import pandas as pd
import csv
import os
import numpy as np
import sys
from aif360.metrics import *
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, roc_curve, auc
plot_model_performance(mdl_rf2, X_test, y_test)
In [178]:
fair = get_fair_metrics_and_plot(filename, data_orig_test, mdl_rf2)
fair
Out[178]:
In [179]:
type(data_orig_train)
Out[179]:
PRE PROCESSING¶
In [180]:
### Reweighing
from aif360.algorithms.preprocessing import Reweighing
RW_rf2 = Reweighing(unprivileged_groups=unprivileged_groups, privileged_groups=privileged_groups)
data_transf_train_rf2_rw = RW_rf2.fit_transform(data_orig_train)
#train and save model
rf2_transf_rw = model_rf2.fit(data_transf_train_rf2_rw.features,
data_transf_train_rf2_rw.labels.ravel())
data_transf_test_rf2_rw = RW_rf2.transform(data_orig_test)
fair_rf2_rw = get_fair_metrics_and_plot(filename, data_transf_test_rf2_rw, rf2_transf_rw, plot=False)
In [181]:
fair_rf_rw
Out[181]:
In [182]:
from aif360.algorithms.preprocessing import DisparateImpactRemover
DIR_rf2 = DisparateImpactRemover()
data_transf_train_rf2_dir = DIR_rf2.fit_transform(data_orig_train)
# Train and save the model
rf2_transf_dir = model_rf2.fit(data_transf_train_rf2_dir.features,data_transf_train_rf2_dir.labels.ravel())
In [183]:
fair_dir_rf2_dir = get_fair_metrics_and_plot(filename,data_orig_test, rf2_transf_dir, plot=False)
fair_dir_rf2_dir
Out[183]:
In [184]:
conf_mat_rf2_dir = confusion_matrix(data_orig_test.labels.ravel(), rf2_transf_dir.predict(data_orig_test.features))
conf_mat_rf2_dir
from sklearn.metrics import accuracy_score
print(accuracy_score(data_orig_test.labels.ravel(), rf2_transf_dir.predict(data_orig_test.features)))
Out[184]:
INPROCESSING¶
In [185]:
#!pip install --user --upgrade tensorflow==1.15.0
#2.2.0
#!pip uninstall tensorflow
In [186]:
#!pip install "tensorflow==1.15"
#!pip install --upgrade tensorflow-hub
In [187]:
#%tensorflow_version 1.15
import tensorflow as tf
#from tensorflow.compat.v1 import variable_scope
print('Using TensorFlow version', tf.__version__)
In [188]:
#sess = tf.compat.v1.Session()
#import tensorflow as tf
sess = tf.compat.v1.Session()
In [189]:
#import tensorflow as tf
#sess = tf.Session()
tf.compat.v1.reset_default_graph()
In [190]:
from aif360.algorithms.inprocessing.adversarial_debiasing import AdversarialDebiasing
#with tf.variable_scope('debiased_classifier',reuse=tf.AUTO_REUSE):
with tf.compat.v1.Session() as sess:
with tf.variable_scope('scope1',reuse=tf.AUTO_REUSE) as scope:
debiased_model_rf2_ad = AdversarialDebiasing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
scope_name=scope,
num_epochs=10,
debias=True,
sess=sess)
#train and save the model
debiased_model_rf2_ad.fit(data_orig_train)
fair_rf2_ad = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_rf2_ad, plot=False, model_aif=True)
Out[190]:
In [191]:
fair_rf2_ad
Out[191]:
In [192]:
from aif360.algorithms.inprocessing import PrejudiceRemover
debiased_model_pr_rf2 = PrejudiceRemover()
# Train and save the model
debiased_model_pr_rf2.fit(data_orig_train)
fair_rf2_pr = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_pr_rf2, plot=False, model_aif=True)
fair_rf2_pr
Out[192]:
Out[192]:
#¶
In [193]:
y_pred = debiased_model_pr_rf2.predict(data_orig_test)
data_orig_test_pred = data_orig_test.copy(deepcopy=True)
In [194]:
# Prediction with the original RandomForest model
scores = np.zeros_like(data_orig_test.labels)
scores = mdl_rf2.predict_proba(data_orig_test.features)[:,1].reshape(-1,1)
data_orig_test_pred.scores = scores
preds = np.zeros_like(data_orig_test.labels)
preds = mdl_rf2.predict(data_orig_test.features).reshape(-1,1)
data_orig_test_pred.labels = preds
def format_probs(probs1):
probs1 = np.array(probs1)
probs0 = np.array(1-probs1)
return np.concatenate((probs0, probs1), axis=1)
POST PROCESSING¶
In [195]:
from aif360.algorithms.postprocessing import EqOddsPostprocessing
EOPP_rf2 = EqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
seed=40)
EOPP_rf2 = EOPP_rf2.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_rf2_eopp = EOPP_rf2.predict(data_orig_test_pred)
fair_rf2_eo = fair_metrics(filename, data_orig_test, data_transf_test_pred_rf2_eopp, pred_is_dataset=True)
In [196]:
fair_rf2_eo
Out[196]:
In [197]:
from aif360.algorithms.postprocessing import CalibratedEqOddsPostprocessing
cost_constraint = "fnr"
CPP_rf2 = CalibratedEqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
cost_constraint=cost_constraint,
seed=42)
CPP_rf2 = CPP_rf2.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_rf2_cpp = CPP_rf2.predict(data_orig_test_pred)
fair_rf2_ceo = fair_metrics(filename, data_orig_test, data_transf_test_pred_rf2_cpp, pred_is_dataset=True)
In [198]:
fair_rf2_ceo
Out[198]:
In [199]:
from aif360.algorithms.postprocessing import RejectOptionClassification
ROC_rf2 = RejectOptionClassification(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups)
ROC_rf2 = ROC_rf2.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_rf2_roc = ROC_rf2.predict(data_orig_test_pred)
fair_rf2_roc = fair_metrics(filename, data_orig_test, data_transf_test_pred_rf2_roc, pred_is_dataset=True)
print('SUCCESS: completed 1 model.')
In [200]:
fair_rf2_roc
Out[200]:
5. KNN¶
In [201]:
from sklearn import neighbors
n_neighbors = 15
knn = neighbors.KNeighborsClassifier(n_neighbors, weights='distance')
In [202]:
knn.fit(data_orig_train.features, data_orig_train.labels.ravel())
Out[202]:
In [203]:
conf_mat_knn = confusion_matrix(data_orig_test.labels.ravel(), knn.predict(data_orig_test.features))
conf_mat_knn
from sklearn.metrics import accuracy_score
print(accuracy_score(data_orig_test.labels.ravel(), knn.predict(data_orig_test.features)))
Out[203]:
5.a. Model Explainability/interpretability¶
5.a.1 Using SHAP (SHapley Additive exPlanations)¶
In [204]:
knn_explainer = shap.KernelExplainer(knn.predict, data_orig_test.features)
knn_shap_values = knn_explainer.shap_values(data_orig_test.features,nsamples=10)
In [205]:
#shap.dependence_plot(0, knn_shap_values, data_orig_test.features)
In [206]:
# plot the SHAP values for the 0th observation
shap.force_plot(knn_explainer.expected_value,knn_shap_values[0,:], data_orig_test.features[0],data_orig_test.feature_names,link='logit')
Out[206]:
In [207]:
# plot the SHAP values for the 1st observation
shap.force_plot(knn_explainer.expected_value,knn_shap_values[1,:], data_orig_test.features[1],data_orig_test.feature_names,link='logit')
Out[207]:
In [208]:
shap.force_plot(knn_explainer.expected_value, knn_shap_values, data_orig_test.feature_names,link='logit')
Out[208]:
In [209]:
shap.summary_plot(knn_shap_values, data_orig_test.features,feature_names=data_orig_test.feature_names, plot_type="violin")
Feature Importance
perm_imp_11=eli5.show_weights(knn,feature_names = data_orig_test.feature_names) perm_imp_11 plt.show()
Explaining individual predictions¶
In [210]:
from eli5 import show_prediction
show_prediction(knn, data_orig_test.features[1], show_feature_values=True,feature_names = data_orig_test.feature_names)
Out[210]:
5.b. Measuring fairness ¶
Of Baseline model ¶
In [211]:
import pandas as pd
import csv
import os
import numpy as np
import sys
from aif360.metrics import *
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, roc_curve, auc
plot_model_performance(knn, X_test, y_test)
In [212]:
fair = get_fair_metrics_and_plot(filename, data_orig_test, knn)
fair
Out[212]:
PRE PROCESSING¶
In [213]:
### Reweighing
from aif360.algorithms.preprocessing import Reweighing
RW_knn = Reweighing(unprivileged_groups=unprivileged_groups, privileged_groups=privileged_groups)
data_transf_train_knn = RW_knn.fit_transform(data_orig_train)
# Train and save the model
knn_transf_rw = knn.fit(data_transf_train_knn.features,
data_transf_train_knn.labels.ravel())
data_transf_test_knn_rw = RW_knn.transform(data_orig_test)
fair_knn_rw = get_fair_metrics_and_plot(filename, data_transf_test_knn_rw, knn_transf_rw, plot=False)
In [214]:
fair_knn_rw
Out[214]:
In [215]:
from aif360.algorithms.preprocessing import DisparateImpactRemover
DIR = DisparateImpactRemover()
data_transf_train_knn_dir = DIR.fit_transform(data_orig_train)
# Train and save the model
knn_transf_dir = knn.fit(data_transf_train_knn_dir.features,
data_transf_train_knn_dir.labels.ravel())
In [216]:
fair_knn_dir = get_fair_metrics_and_plot(filename, data_orig_test, knn_transf_dir, plot=False)
fair_knn_dir
Out[216]:
INPROCESSING¶
In [217]:
#!pip install tensorflow
import tensorflow as tf
#from tensorflow.compat.v1 import variable_scope
print('Using TensorFlow version', tf.__version__)
In [218]:
#sess = tf.compat.v1.Session()
#import tensorflow as tf
sess = tf.compat.v1.Session()
In [219]:
#import tensorflow as tf
#sess = tf.Session()
tf.compat.v1.reset_default_graph()
In [220]:
from aif360.algorithms.inprocessing.adversarial_debiasing import AdversarialDebiasing
#with tf.variable_scope('debiased_classifier',reuse=tf.AUTO_REUSE):
with tf.compat.v1.Session() as sess:
with tf.variable_scope('scope4',reuse=tf.AUTO_REUSE) as scope:
debiased_model_knn_ad = AdversarialDebiasing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
scope_name=scope,
num_epochs=10,
debias=True,
sess=sess)
debiased_model_knn_ad.fit(data_orig_train)
fair_knn_ad = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_knn_ad, plot=False, model_aif=True)
Out[220]:
In [221]:
fair_knn_ad
Out[221]:
In [222]:
from aif360.algorithms.inprocessing import PrejudiceRemover
debiased_model_knn_pr = PrejudiceRemover()
# Train and save the model
debiased_model_knn_pr.fit(data_orig_train)
fair_knn_pr = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_knn_pr, plot=False, model_aif=True)
fair_knn_pr
Out[222]:
Out[222]:
#¶
In [223]:
y_pred = debiased_model_knn_pr.predict(data_orig_test)
data_orig_test_pred = data_orig_test.copy(deepcopy=True)
In [224]:
# Prediction with the original RandomForest model
scores = np.zeros_like(data_orig_test.labels)
scores = knn.predict_proba(data_orig_test.features)[:,1].reshape(-1,1)
data_orig_test_pred.scores = scores
preds = np.zeros_like(data_orig_test.labels)
preds = knn.predict(data_orig_test.features).reshape(-1,1)
data_orig_test_pred.labels = preds
def format_probs(probs1):
probs1 = np.array(probs1)
probs0 = np.array(1-probs1)
return np.concatenate((probs0, probs1), axis=1)
POST PROCESSING¶
In [225]:
from aif360.algorithms.postprocessing import EqOddsPostprocessing
EOPP_knn = EqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
seed=40)
EOPP_knn = EOPP_knn.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_knn_eop = EOPP_knn.predict(data_orig_test_pred)
fair_knn_eo = fair_metrics(filename, data_orig_test, data_transf_test_pred_knn_eop, pred_is_dataset=True)
In [226]:
fair_knn_eo
Out[226]:
In [227]:
from aif360.algorithms.postprocessing import CalibratedEqOddsPostprocessing
cost_constraint = "fnr"
CPP_knn = CalibratedEqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
cost_constraint=cost_constraint,
seed=40)
CPP_knn = CPP_knn.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_knn_cp = CPP_knn.predict(data_orig_test_pred)
fair_knn_ceo = fair_metrics(filename, data_orig_test, data_transf_test_pred_knn_cp, pred_is_dataset=True)
In [228]:
fair_knn_ceo
Out[228]:
In [229]:
from aif360.algorithms.postprocessing import RejectOptionClassification
ROC_knn = RejectOptionClassification(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups)
ROC_knn = ROC_knn.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_knn_roc = ROC_knn.predict(data_orig_test_pred)
fair_knn_roc = fair_metrics(filename, data_orig_test, data_transf_test_pred_knn_roc, pred_is_dataset=True)
print('SUCCESS: completed 1 model.')
In [230]:
fair_knn_roc
Out[230]:
6. Logistic Regression¶
In [231]:
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
In [232]:
lr.fit(data_orig_train.features, data_orig_train.labels.ravel())
Out[232]:
In [233]:
conf_mat_lr = confusion_matrix(data_orig_test.labels.ravel(), lr.predict(data_orig_test.features))
conf_mat_lr
from sklearn.metrics import accuracy_score
print(accuracy_score(data_orig_test.labels.ravel(), lr.predict(data_orig_test.features)))
Out[233]:
6.a. Model Explainability/interpretability¶
6.a.1 Using SHAP (SHapley Additive exPlanations)¶
In [234]:
lr_explainer = shap.KernelExplainer(lr.predict, data_orig_test.features)
lr_shap_values = lr_explainer.shap_values(data_orig_test.features,nsamples=10)
In [235]:
# plot the SHAP values for the 0th observation
shap.force_plot(lr_explainer.expected_value,lr_shap_values[0,:], data_orig_test.features[0],data_orig_test.feature_names,link='logit')
Out[235]:
In [236]:
# plot the SHAP values for the 1st observation
shap.force_plot(lr_explainer.expected_value,lr_shap_values[1,:], data_orig_test.features[1],data_orig_test.feature_names,link='logit')
Out[236]:
In [237]:
shap.force_plot(lr_explainer.expected_value, lr_shap_values, data_orig_test.feature_names,link='logit')
Out[237]:
In [238]:
shap.summary_plot(lr_shap_values, data_orig_test.features,feature_names=data_orig_test.feature_names, plot_type="violin")
Feature Importance
perm_imp_11=eli5.show_weights(knn,feature_names = data_orig_test.feature_names) perm_imp_11 plt.show()
Explaining individual predictions¶
In [239]:
from eli5 import show_prediction
show_prediction(lr, data_orig_test.features[1], show_feature_values=True,feature_names = data_orig_test.feature_names)
Out[239]:
6.b. Measuring fairness ¶
Of Baseline model ¶
In [240]:
import pandas as pd
import csv
import os
import numpy as np
import sys
from aif360.metrics import *
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, roc_curve, auc
plot_model_performance(lr, X_test, y_test)
In [241]:
fair = get_fair_metrics_and_plot(filename, data_orig_test, lr)
fair
Out[241]:
PRE PROCESSING¶
In [242]:
### Reweighing
from aif360.algorithms.preprocessing import Reweighing
RW_lr = Reweighing(unprivileged_groups=unprivileged_groups, privileged_groups=privileged_groups)
data_transf_train_lr = RW_lr.fit_transform(data_orig_train)
# Train and save the model
lr_transf_rw = lr.fit(data_transf_train_knn.features,
data_transf_train_knn.labels.ravel())
data_transf_test_lr_rw = RW_lr.transform(data_orig_test)
fair_lr_rw = get_fair_metrics_and_plot(filename, data_transf_test_lr_rw, lr_transf_rw, plot=False)
In [243]:
fair_lr_rw
Out[243]:
In [244]:
from aif360.algorithms.preprocessing import DisparateImpactRemover
DIR = DisparateImpactRemover()
data_transf_train_lr_dir = DIR.fit_transform(data_orig_train)
# Train and save the model
lr_transf_dir = lr.fit(data_transf_train_lr_dir.features,
data_transf_train_lr_dir.labels.ravel())
In [245]:
fair_lr_dir = get_fair_metrics_and_plot(filename, data_orig_test, lr_transf_dir, plot=False)
fair_lr_dir
Out[245]:
INPROCESSING¶
In [246]:
#!pip install tensorflow
import tensorflow as tf
#from tensorflow.compat.v1 import variable_scope
print('Using TensorFlow version', tf.__version__)
In [247]:
#sess = tf.compat.v1.Session()
#import tensorflow as tf
sess = tf.compat.v1.Session()
In [248]:
#import tensorflow as tf
#sess = tf.Session()
tf.compat.v1.reset_default_graph()
In [249]:
from aif360.algorithms.inprocessing.adversarial_debiasing import AdversarialDebiasing
#with tf.variable_scope('debiased_classifier',reuse=tf.AUTO_REUSE):
with tf.compat.v1.Session() as sess:
with tf.variable_scope('scope5',reuse=tf.AUTO_REUSE) as scope:
debiased_model_lr_ad = AdversarialDebiasing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
scope_name=scope,
num_epochs=10,
debias=True,
sess=sess)
debiased_model_lr_ad.fit(data_orig_train)
fair_lr_ad = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_lr_ad, plot=False, model_aif=True)
Out[249]:
In [250]:
fair_lr_ad
Out[250]:
In [251]:
from aif360.algorithms.inprocessing import PrejudiceRemover
debiased_model_lr_pr = PrejudiceRemover()
# Train and save the model
debiased_model_lr_pr.fit(data_orig_train)
fair_lr_pr = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_lr_pr, plot=False, model_aif=True)
fair_lr_pr
Out[251]:
Out[251]:
#¶
In [252]:
y_pred = debiased_model_lr_pr.predict(data_orig_test)
data_orig_test_pred = data_orig_test.copy(deepcopy=True)
In [253]:
# Prediction with the original RandomForest model
scores = np.zeros_like(data_orig_test.labels)
scores = lr.predict_proba(data_orig_test.features)[:,1].reshape(-1,1)
data_orig_test_pred.scores = scores
preds = np.zeros_like(data_orig_test.labels)
preds = lr.predict(data_orig_test.features).reshape(-1,1)
data_orig_test_pred.labels = preds
def format_probs(probs1):
probs1 = np.array(probs1)
probs0 = np.array(1-probs1)
return np.concatenate((probs0, probs1), axis=1)
POST PROCESSING¶
In [254]:
from aif360.algorithms.postprocessing import EqOddsPostprocessing
EOPP_lr = EqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
seed=40)
EOPP_lr = EOPP_lr.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_lr_eop = EOPP_lr.predict(data_orig_test_pred)
fair_lr_eo = fair_metrics(filename, data_orig_test, data_transf_test_pred_lr_eop, pred_is_dataset=True)
In [255]:
fair_lr_eo
Out[255]:
In [256]:
from aif360.algorithms.postprocessing import CalibratedEqOddsPostprocessing
cost_constraint = "fnr"
CPP_lr = CalibratedEqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
cost_constraint=cost_constraint,
seed=40)
CPP_lr = CPP_lr.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_lr_cp = CPP_lr.predict(data_orig_test_pred)
fair_lr_ceo = fair_metrics(filename, data_orig_test, data_transf_test_pred_lr_cp, pred_is_dataset=True)
In [257]:
fair_lr_ceo
Out[257]:
In [258]:
from aif360.algorithms.postprocessing import RejectOptionClassification
ROC_lr = RejectOptionClassification(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups)
ROC_lr = ROC_lr.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_lr_roc = ROC_lr.predict(data_orig_test_pred)
fair_lr_roc = fair_metrics(filename, data_orig_test, data_transf_test_pred_lr_roc, pred_is_dataset=True)
print('SUCCESS: completed 1 model.')
In [259]:
fair_lr_roc
Out[259]:
In [ ]:
7. SVM¶
In [260]:
from sklearn.svm import SVC
#gs = grid_search_cv.best_estimator_
svm = SVC(C=0.85, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='scale', kernel='linear',
max_iter=-1, random_state=42, shrinking=True, tol=0.001, probability=True,
verbose=False)
svm.fit(data_orig_train.features, data_orig_train.labels.ravel())
Out[260]:
In [261]:
conf_mat_svm = confusion_matrix(data_orig_test.labels.ravel(), svm.predict(data_orig_test.features))
conf_mat_svm
from sklearn.metrics import accuracy_score
print(accuracy_score(data_orig_test.labels.ravel(), svm.predict(data_orig_test.features)))
Out[261]:
7.a. Model Explainability/interpretability¶
7.a.1 Using SHAP (SHapley Additive exPlanations)¶
In [262]:
svm_explainer = shap.KernelExplainer(svm.predict, data_orig_test.features)
svm_shap_values = svm_explainer.shap_values(data_orig_test.features,nsamples=10)
In [263]:
# plot the SHAP values for the 0th observation
shap.force_plot(svm_explainer.expected_value,svm_shap_values[0,:], data_orig_test.features[0],data_orig_test.feature_names,link='logit')
Out[263]:
In [264]:
# plot the SHAP values for the 1st observation
shap.force_plot(svm_explainer.expected_value,svm_shap_values[1,:], data_orig_test.features[1],data_orig_test.feature_names,link='logit')
Out[264]:
In [265]:
shap.force_plot(svm_explainer.expected_value, svm_shap_values, data_orig_test.feature_names,link='logit')
Out[265]:
In [266]:
shap.summary_plot(svm_shap_values, data_orig_test.features,feature_names=data_orig_test.feature_names, plot_type="violin")
Feature Importance
perm_imp_11=eli5.show_weights(knn,feature_names = data_orig_test.feature_names) perm_imp_11 plt.show()
Explaining individual predictions¶
In [267]:
from eli5 import show_prediction
show_prediction(svm, data_orig_test.features[1], show_feature_values=True,feature_names = data_orig_test.feature_names)
Out[267]:
7.b. Measuring fairness ¶
Of Baseline model ¶
In [268]:
import pandas as pd
import csv
import os
import numpy as np
import sys
from aif360.metrics import *
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score, roc_curve, auc
plot_model_performance(svm, X_test, y_test)
In [269]:
fair_svm = get_fair_metrics_and_plot(filename, data_orig_test, svm)
fair_svm
Out[269]:
PRE PROCESSING¶
In [270]:
### Reweighing
from aif360.algorithms.preprocessing import Reweighing
RW_svm = Reweighing(unprivileged_groups=unprivileged_groups, privileged_groups=privileged_groups)
data_transf_train_svm = RW_svm.fit_transform(data_orig_train)
# Train and save the model
svm_transf_rw = svm.fit(data_transf_train_knn.features,
data_transf_train_knn.labels.ravel())
data_transf_test_svm_rw = RW_svm.transform(data_orig_test)
fair_svm_rw = get_fair_metrics_and_plot(filename, data_transf_test_svm_rw, svm_transf_rw, plot=False)
In [271]:
fair_svm_rw
Out[271]:
In [272]:
from aif360.algorithms.preprocessing import DisparateImpactRemover
DIR = DisparateImpactRemover()
data_transf_train_svm_dir = DIR.fit_transform(data_orig_train)
# Train and save the model
svm_transf_dir = svm.fit(data_transf_train_svm_dir.features,
data_transf_train_svm_dir.labels.ravel())
In [273]:
fair_svm_dir = get_fair_metrics_and_plot(filename, data_orig_test, svm_transf_dir, plot=False)
fair_svm_dir
Out[273]:
INPROCESSING¶
In [274]:
#!pip install tensorflow
import tensorflow as tf
#from tensorflow.compat.v1 import variable_scope
print('Using TensorFlow version', tf.__version__)
In [275]:
#sess = tf.compat.v1.Session()
#import tensorflow as tf
sess = tf.compat.v1.Session()
In [276]:
#import tensorflow as tf
#sess = tf.Session()
tf.compat.v1.reset_default_graph()
In [277]:
from aif360.algorithms.inprocessing.adversarial_debiasing import AdversarialDebiasing
#with tf.variable_scope('debiased_classifier',reuse=tf.AUTO_REUSE):
with tf.compat.v1.Session() as sess:
with tf.variable_scope('scope6',reuse=tf.AUTO_REUSE) as scope:
debiased_model_svm_ad = AdversarialDebiasing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
scope_name=scope,
num_epochs=10,
debias=True,
sess=sess)
debiased_model_svm_ad.fit(data_orig_train)
fair_svm_ad = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_svm_ad, plot=False, model_aif=True)
Out[277]:
In [278]:
fair_svm_ad
Out[278]:
In [279]:
from aif360.algorithms.inprocessing import PrejudiceRemover
debiased_model_svm_pr = PrejudiceRemover()
# Train and save the model
debiased_model_svm_pr.fit(data_orig_train)
fair_svm_pr = get_fair_metrics_and_plot(filename, data_orig_test, debiased_model_svm_pr, plot=False, model_aif=True)
fair_svm_pr
Out[279]:
Out[279]:
#¶
In [280]:
y_pred = debiased_model_svm_pr.predict(data_orig_test)
data_orig_test_pred = data_orig_test.copy(deepcopy=True)
In [281]:
# Prediction with the original RandomForest model
scores = np.zeros_like(data_orig_test.labels)
scores = svm.predict_proba(data_orig_test.features)[:,1].reshape(-1,1)
data_orig_test_pred.scores = scores
preds = np.zeros_like(data_orig_test.labels)
preds = svm.predict(data_orig_test.features).reshape(-1,1)
data_orig_test_pred.labels = preds
def format_probs(probs1):
probs1 = np.array(probs1)
probs0 = np.array(1-probs1)
return np.concatenate((probs0, probs1), axis=1)
POST PROCESSING¶
In [282]:
from aif360.algorithms.postprocessing import EqOddsPostprocessing
EOPP_svm = EqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
seed=40)
EOPP_svm = EOPP_svm.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_svm_eop = EOPP_svm.predict(data_orig_test_pred)
fair_svm_eo = fair_metrics(filename, data_orig_test, data_transf_test_pred_svm_eop, pred_is_dataset=True)
In [283]:
fair_svm_eo
Out[283]:
In [284]:
from aif360.algorithms.postprocessing import CalibratedEqOddsPostprocessing
cost_constraint = "fnr"
CPP_svm = CalibratedEqOddsPostprocessing(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups,
cost_constraint=cost_constraint,
seed=40)
CPP_svm = CPP_svm.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_svm_cp = CPP_svm.predict(data_orig_test_pred)
fair_svm_ceo = fair_metrics(filename, data_orig_test, data_transf_test_pred_svm_cp, pred_is_dataset=True)
In [285]:
fair_svm_ceo
Out[285]:
In [286]:
from aif360.algorithms.postprocessing import RejectOptionClassification
ROC_svm = RejectOptionClassification(privileged_groups = privileged_groups,
unprivileged_groups = unprivileged_groups)
ROC_svm = ROC_svm.fit(data_orig_test, data_orig_test_pred)
data_transf_test_pred_svm_roc = ROC_svm.predict(data_orig_test_pred)
fair_svm_roc = fair_metrics(filename, data_orig_test, data_transf_test_pred_svm_roc, pred_is_dataset=True)
print('SUCCESS: completed 1 model.')
In [287]:
fair_svm_roc
Out[287]:
In [ ]: